package com.example.smssender;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Handler;
import android.os.Looper;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.telephony.SmsManager;
import android.telephony.TelephonyManager;
import android.telephony.SubscriptionManager;
import android.telephony.SubscriptionInfo;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import androidx.core.app.NotificationCompat;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.core.content.ContextCompat;
import com.google.android.material.button.MaterialButton;
import com.google.android.material.textfield.TextInputEditText;
import com.google.android.material.textfield.TextInputLayout;
import com.google.android.material.switchmaterial.SwitchMaterial;
import com.google.android.material.card.MaterialCardView;
import com.google.android.material.chip.ChipGroup;
import com.google.android.material.chip.Chip;
import android.widget.LinearLayout;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private static final int REQUEST_SELECT_CONTACTS = 200;
    private static final int REQUEST_SELECT_TEMPLATE = 201;
    private static final int REQUEST_CONTENT_GENERATOR = 202;
    private static final String SMS_SENT_ACTION = "com.example.smssender.SMS_SENT";
    private static final String SMS_DELIVERED_ACTION = "com.example.smssender.SMS_DELIVERED";
    
    // 通知相关
    private static final String CHANNEL_ID = "sms_sending_progress";
    private static final int NOTIFICATION_ID = 1001;
    
    // 发送间隔配置（毫秒）
    private static final String PREF_NAME = "sms_sender_prefs";
    private static final String PREF_SEND_INTERVAL = "send_interval_ms";
    private static final long DEFAULT_SEND_INTERVAL_MS = 1000; // 默认1秒间隔
    
    private TextInputEditText etPhoneNumber;
    private TextInputEditText etMessage;
    private Button btnSendSMS;
    private Button btnManageContacts;
    private Button btnManageTemplates;
    private Button btnSendRecords;
    private Button btnSelectContacts;
    private Button btnSelectTemplate;
    private Button btnSettings;
    private Button btnContentGenerator;
    private SwitchMaterial switchAddGreeting;
    private LinearLayout llGreetingOptions;
    private ChipGroup chipGroupGreeting;
    private String selectedGreeting = "你好，"; // 默认称谓
    
    // 新的UI组件
    private LinearLayout llSelectedContactsSummary;
    private LinearLayout llSelectedTemplateContent;
    private TextView tvSelectedTemplateTitle;
    private TextView tvSelectedTemplateContent;
    private TextView tvSelectedCount;
    private Button btnViewAllContacts;
    private Button btnClearSelected;
    private RecyclerView rvContactPreview;
    private ContactPreviewAdapter previewAdapter;
    
    // 进度显示UI组件
    private MaterialCardView cardSendingProgress;
    private ProgressBar progressBar;
    private TextView tvProgressText;
    private TextView tvCurrentSending;
    private TextView tvProgressStats;
    private Button btnViewProgressDetail;
    
    // 发送状态跟踪
    private List<SendingStatus> sendingStatusList = new ArrayList<>();
    private SendingProgressBottomSheetDialog progressBottomSheet;
    private NotificationManager notificationManager;
    
    private Contact[] selectedContacts = new Contact[0];
    private SmsTemplate selectedTemplate = null;
    private boolean addGreeting = false; // 是否添加称谓
    
    private BroadcastReceiver smsSentReceiver;
    private BroadcastReceiver smsDeliveredReceiver;
    private int totalSmsCount = 0;
    private int successCount = 0;
    private int failCount = 0;
    
    // 权限请求 Launcher（支持多个权限一次性请求）
    private ActivityResultLauncher<String[]> smsPermissionLauncher;
    
    // 用于存储待发送的短信数据（在权限授予后继续发送）
    private List<String> pendingPhoneNumbers = null;
    private String pendingMessage = null;
    
    // 用于保存当前发送的消息内容（在发送完成后保存记录时使用）
    private String currentSendingMessage = null;
    
    // PendingIntent request code 计数器，确保唯一性
    private int pendingIntentRequestCode = 0;
    
    // 标记是否正在处理权限请求，防止重复请求
    private boolean isRequestingPermission = false;
    
    // 标记是否正在发送短信，防止重复发送
    private boolean isSending = false;
    
    // Handler 用于延迟发送
    private Handler sendHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate: 开始创建Activity");
        setContentView(R.layout.activity_main);

        // 初始化权限请求 Launcher
        initPermissionLauncher();

        // 初始化Handler
        sendHandler = new Handler(Looper.getMainLooper());

        // 初始化通知管理器
        notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        createNotificationChannel();

        // 初始化视图
        initViews();

        // 恢复保存的状态（如果Activity被系统销毁并重新创建）
        if (savedInstanceState != null) {
            restoreInstanceState(savedInstanceState);
        }

        // 更新UI显示（恢复状态后需要更新显示）
        updateSelectedContactsDisplay();
        updateSelectedTemplateDisplay();

        // 注册广播接收器
        registerSmsReceivers();

        // 检查是否在模拟器上
        if (isEmulator()) {
            Log.w(TAG, "onCreate: 检测到运行在模拟器上");
            Toast.makeText(this, "提示：当前在模拟器上运行，短信可能无法真正发送", Toast.LENGTH_LONG).show();
        }
    }

    /**
     * 初始化权限请求 Launcher（一次性请求所有需要的权限）
     */
    private void initPermissionLauncher() {
        smsPermissionLauncher = registerForActivityResult(
            new ActivityResultContracts.RequestMultiplePermissions(),
            permissions -> {
                isRequestingPermission = false; // 权限请求完成，重置标志
                
                // 检查所有权限是否都已授予
                boolean smsGranted = permissions.getOrDefault(Manifest.permission.SEND_SMS, false);
                boolean phoneStateGranted = permissions.getOrDefault(Manifest.permission.READ_PHONE_STATE, false);
                
                Log.d(TAG, "initPermissionLauncher: SEND_SMS权限=" + smsGranted + ", READ_PHONE_STATE权限=" + phoneStateGranted);
                
                // SEND_SMS是必需的，READ_PHONE_STATE是可选的（用于获取SIM卡信息）
                if (smsGranted) {
                    Log.d(TAG, "initPermissionLauncher: 短信权限已授予");
                    if (phoneStateGranted) {
                        Log.d(TAG, "initPermissionLauncher: 电话状态权限已授予");
                    } else {
                        Log.w(TAG, "initPermissionLauncher: 电话状态权限未授予（不影响短信发送，但可能无法获取SIM卡信息）");
                    }
                    
                    // 检查用户是否选择了"仅此一次"（临时权限）
                    // 注意：Android系统可能不提供"始终允许"选项，特别是首次请求时
                    // 如果用户选择了"允许一次"，下次使用时会再次弹出权限请求
                    // 这是Android系统的正常行为，无法通过代码改变
                    boolean shouldShowRationale = shouldShowRequestPermissionRationale(Manifest.permission.SEND_SMS);
                    
                    // 如果有待发送的短信，继续发送
                    if (pendingPhoneNumbers != null && pendingMessage != null) {
                        sendSMSInternal(pendingPhoneNumbers, pendingMessage);
                        pendingPhoneNumbers = null;
                        pendingMessage = null;
                    }
                    
                    // 提示用户：如果权限提示框只显示"拒绝"和"允许一次"是正常的
                    // 如果希望长期使用，可以到设置中授予永久权限
                    Toast.makeText(this, "权限已授予，继续发送短信", Toast.LENGTH_SHORT).show();
                } else {
                    Log.w(TAG, "initPermissionLauncher: 短信权限被拒绝");
                    
                    // 检查是否应该显示解释说明
                    boolean shouldShowRationale = shouldShowRequestPermissionRationale(Manifest.permission.SEND_SMS);
                    
                    if (shouldShowRationale) {
                        // 用户之前拒绝过，现在再次拒绝，引导到设置
                        showPermissionDeniedDialog();
                    } else {
                        // 首次拒绝，可能是用户选择了"拒绝"或系统只显示了"拒绝"和"允许一次"
                        Toast.makeText(this, "需要短信权限才能发送短信\n提示：如果权限提示框只显示\"拒绝\"和\"允许一次\"是正常的\n如需长期使用，请到设置中授予权限", Toast.LENGTH_LONG).show();
                    }
                    
                    // 注意：不永久禁用按钮，因为用户可能稍后在设置中授予权限
                    // 应用恢复时会根据权限状态自动更新按钮状态
                    // 清空待发送的数据
                    pendingPhoneNumbers = null;
                    pendingMessage = null;
                }
            }
        );
    }

    /**
     * 显示权限被拒绝的对话框，引导用户到设置页面
     */
    private void showPermissionDeniedDialog() {
        new AlertDialog.Builder(this)
            .setTitle("需要短信权限")
            .setMessage("应用需要短信权限才能发送短信。\n\n" +
                       "说明：\n" +
                       "• 如果权限提示框只显示\"拒绝\"和\"允许一次\"是正常的\n" +
                       "• 这是Android系统的安全机制，无法通过代码改变\n" +
                       "• 如果希望长期使用，请到设置中授予永久权限\n\n" +
                       "是否前往设置页面授予权限？")
            .setPositiveButton("前往设置", (dialog, which) -> {
                // 打开应用的设置页面
                Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                Uri uri = Uri.fromParts("package", getPackageName(), null);
                intent.setData(uri);
                startActivity(intent);
            })
            .setNegativeButton("取消", (dialog, which) -> {
                dialog.dismiss();
            })
            .setCancelable(true)
            .show();
    }

    private void initViews() {
        etPhoneNumber = findViewById(R.id.etPhoneNumber);
        etMessage = findViewById(R.id.etMessage);
        btnSendSMS = findViewById(R.id.btnSendSMS);
        btnManageContacts = findViewById(R.id.btnManageContacts);
        btnManageTemplates = findViewById(R.id.btnManageTemplates);
        btnSendRecords = findViewById(R.id.btnSendRecords);
        btnSelectContacts = findViewById(R.id.btnSelectContacts);
        btnSelectTemplate = findViewById(R.id.btnSelectTemplate);
        btnSettings = findViewById(R.id.btnSettings);
        btnContentGenerator = findViewById(R.id.btnContentGenerator);
        switchAddGreeting = findViewById(R.id.switchAddGreeting);
        llGreetingOptions = findViewById(R.id.llGreetingOptions);
        chipGroupGreeting = findViewById(R.id.chipGroupGreeting);
        
        // 初始化新的UI组件
        llSelectedContactsSummary = findViewById(R.id.llSelectedContactsSummary);
        llSelectedTemplateContent = findViewById(R.id.llSelectedTemplateContent);
        tvSelectedTemplateTitle = findViewById(R.id.tvSelectedTemplateTitle);
        tvSelectedTemplateContent = findViewById(R.id.tvSelectedTemplateContent);
        tvSelectedCount = findViewById(R.id.tvSelectedCount);
        btnViewAllContacts = findViewById(R.id.btnViewAllContacts);
        btnClearSelected = findViewById(R.id.btnClearSelected);
        rvContactPreview = findViewById(R.id.rvContactPreview);
        
        // 初始化预览列表
        previewAdapter = new ContactPreviewAdapter(new ArrayList<>(), contact -> {
            // 从选中列表中移除联系人
            removeContactFromSelection(contact);
        });
        rvContactPreview.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false));
        rvContactPreview.setAdapter(previewAdapter);
        
        // 初始化进度显示UI
        cardSendingProgress = findViewById(R.id.cardSendingProgress);
        progressBar = findViewById(R.id.progressBar);
        tvProgressText = findViewById(R.id.tvProgressText);
        tvCurrentSending = findViewById(R.id.tvCurrentSending);
        tvProgressStats = findViewById(R.id.tvProgressStats);
        btnViewProgressDetail = findViewById(R.id.btnViewProgressDetail);
        
        // 查看详情按钮点击事件
        btnViewProgressDetail.setOnClickListener(v -> showProgressBottomSheet());

        // 设置按钮点击事件
        btnManageContacts.setOnClickListener(v -> {
            Intent intent = new Intent(this, ContactListActivity.class);
            startActivity(intent);
        });

        btnManageTemplates.setOnClickListener(v -> {
            Intent intent = new Intent(this, SmsTemplateListActivity.class);
            startActivity(intent);
        });

        btnSendRecords.setOnClickListener(v -> {
            Intent intent = new Intent(this, SmsSendRecordListActivity.class);
            startActivity(intent);
        });

        btnSelectContacts.setOnClickListener(v -> {
            Intent intent = new Intent(this, ContactListActivity.class);
            intent.putExtra(ContactListActivity.EXTRA_SELECT_MODE, true);
            // 传递当前已选择的联系人列表，以便在选择页面恢复选中状态
            if (selectedContacts != null && selectedContacts.length > 0) {
                ArrayList<Contact> selectedList = new ArrayList<>(Arrays.asList(selectedContacts));
                intent.putExtra(ContactListActivity.EXTRA_INITIAL_SELECTED_CONTACTS, selectedList);
                Log.d(TAG, "btnSelectContacts点击: 传递 " + selectedList.size() + " 个已选联系人到选择页面");
            } else {
                Log.d(TAG, "btnSelectContacts点击: 当前没有已选联系人");
            }
            startActivityForResult(intent, REQUEST_SELECT_CONTACTS);
        });

        btnSelectTemplate.setOnClickListener(v -> {
            Intent intent = new Intent(this, SmsTemplateListActivity.class);
            intent.putExtra(SmsTemplateListActivity.EXTRA_SELECT_MODE, true);
            startActivityForResult(intent, REQUEST_SELECT_TEMPLATE);
        });

        btnContentGenerator.setOnClickListener(v -> {
            Intent intent = new Intent(this, SmsContentGeneratorActivity.class);
            startActivityForResult(intent, REQUEST_CONTENT_GENERATOR);
        });

        btnSendSMS.setOnClickListener(v -> sendSMS());

        btnSettings.setOnClickListener(v -> showSettingsDialog());
        
        // 查看全部按钮
        btnViewAllContacts.setOnClickListener(v -> showSelectedContactsBottomSheet());
        
        // 清空选择按钮
        btnClearSelected.setOnClickListener(v -> clearSelectedContacts());
        
        // 初始化称谓相关状态
        addGreeting = switchAddGreeting.isChecked();
        llGreetingOptions.setVisibility(addGreeting ? View.VISIBLE : View.GONE);
        
        // 同步默认选中的称谓文本
        int checkedChipId = chipGroupGreeting.getCheckedChipId();
        if (checkedChipId != View.NO_ID) {
            Chip defaultChip = findViewById(checkedChipId);
            if (defaultChip != null) {
                selectedGreeting = defaultChip.getText().toString();
                Log.d(TAG, "初始化默认称谓: " + selectedGreeting);
            }
        }
        
        // 添加称谓开关监听器
        switchAddGreeting.setOnCheckedChangeListener((buttonView, isChecked) -> {
            addGreeting = isChecked;
            // 显示或隐藏称谓选择区域
            llGreetingOptions.setVisibility(isChecked ? View.VISIBLE : View.GONE);
            Log.d(TAG, "switchAddGreeting: 添加称谓状态已更改为 " + addGreeting);
        });
        
        // 称谓选择监听器
        chipGroupGreeting.setOnCheckedChangeListener((group, checkedId) -> {
            Chip selectedChip = findViewById(checkedId);
            if (selectedChip != null) {
                selectedGreeting = selectedChip.getText().toString();
                Log.d(TAG, "称谓已选择: " + selectedGreeting);
            }
        });
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        
        if (requestCode == REQUEST_SELECT_CONTACTS) {
            // 处理联系人选择结果
            if (resultCode == RESULT_OK && data != null) {
                @SuppressWarnings("unchecked")
                ArrayList<Contact> contactsList = (ArrayList<Contact>) data.getSerializableExtra(ContactListActivity.RESULT_SELECTED_CONTACTS);
                if (contactsList != null) {
                    // 即使列表为空，也要更新（用户可能清空了所有选择）
                    selectedContacts = contactsList.toArray(new Contact[0]);
                    updateSelectedContactsDisplay();
                    Log.d(TAG, "onActivityResult: 更新联系人选择，数量=" + selectedContacts.length);
                }
            } else {
                // 用户取消选择，保持原有选择不变
                Log.d(TAG, "onActivityResult: 用户取消联系人选择，保持原有选择");
            }
        } else if (requestCode == REQUEST_SELECT_TEMPLATE) {
            // 处理模板选择结果
            if (resultCode == RESULT_OK && data != null) {
                SmsTemplate template = (SmsTemplate) data.getSerializableExtra(SmsTemplateListActivity.RESULT_SELECTED_TEMPLATE);
                if (template != null) {
                    selectedTemplate = template;
                    etMessage.setText(template.getContent());
                    updateSelectedTemplateDisplay();
                    Log.d(TAG, "onActivityResult: 已选择模板 - " + template.getTitle());
                }
            } else {
                // 用户取消选择模板，保持原有模板不变
                Log.d(TAG, "onActivityResult: 用户取消模板选择，保持原有模板");
            }
        } else if (requestCode == REQUEST_CONTENT_GENERATOR) {
            // 处理内容生成结果
            if (resultCode == RESULT_OK && data != null) {
                String generatedContent = data.getStringExtra(SmsContentGeneratorActivity.RESULT_GENERATED_CONTENT);
                if (generatedContent != null && !generatedContent.isEmpty()) {
                    etMessage.setText(generatedContent);
                    Toast.makeText(this, "内容已填充", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }

    private void updateSelectedContactsDisplay() {
        if (selectedContacts != null && selectedContacts.length > 0) {
            // 显示统计卡片
            if (llSelectedContactsSummary != null) {
                llSelectedContactsSummary.setVisibility(View.VISIBLE);
            }
            if (tvSelectedCount != null) {
                tvSelectedCount.setText("已选择 " + selectedContacts.length + " 个联系人");
            }
            
            // 更新预览列表
            if (previewAdapter != null) {
                List<Contact> contactList = Arrays.asList(selectedContacts);
                previewAdapter.updateContacts(contactList);
            }
        } else {
            // 隐藏统计卡片
            if (llSelectedContactsSummary != null) {
                llSelectedContactsSummary.setVisibility(View.GONE);
            }
        }
    }
    
    /**
     * 生成联系人的唯一键（ID+电话号码组合）
     */
    private static String getContactKey(Contact contact) {
        if (contact == null) {
            return null;
        }
        String id = contact.getId() != null ? contact.getId() : "";
        String phone = contact.getPhoneNumber() != null ? contact.getPhoneNumber() : "";
        return id + "|" + phone; // 使用 | 分隔符，因为电话号码中不会包含这个字符
    }
    
    /**
     * 从选中列表中移除联系人
     */
    private void removeContactFromSelection(Contact contact) {
        if (contact == null) {
            return;
        }
        
        if (selectedContacts == null) {
            selectedContacts = new Contact[0];
            return;
        }
        
        String targetKey = getContactKey(contact);
        if (targetKey == null) {
            return;
        }
        
        List<Contact> contactList = new ArrayList<>(Arrays.asList(selectedContacts));
        contactList.removeIf(c -> {
            String key = getContactKey(c);
            return key != null && key.equals(targetKey);
        });
        selectedContacts = contactList.toArray(new Contact[0]);
        updateSelectedContactsDisplay();
    }
    
    /**
     * 清空所有选中的联系人
     */
    private void clearSelectedContacts() {
        selectedContacts = new Contact[0];
        updateSelectedContactsDisplay();
        Toast.makeText(this, "已清空所有选择", Toast.LENGTH_SHORT).show();
    }
    
    /**
     * 显示已选择联系人的详情对话框（BottomSheet）
     */
    private void showSelectedContactsBottomSheet() {
        if (selectedContacts == null) {
            selectedContacts = new Contact[0];
        }
        List<Contact> currentSelected = Arrays.asList(selectedContacts);
        SelectedContactsBottomSheetDialog dialog = SelectedContactsBottomSheetDialog.newInstance(
                currentSelected,
                new SelectedContactsBottomSheetDialog.OnContactsChangedListener() {
                    @Override
                    public void onContactsChanged(List<Contact> selectedContacts) {
                        // 实时更新选中列表
                        if (selectedContacts != null) {
                            MainActivity.this.selectedContacts = selectedContacts.toArray(new Contact[0]);
                            updateSelectedContactsDisplay();
                        }
                    }
                    
                    @Override
                    public void onConfirm(List<Contact> selectedContacts) {
                        // 确认选择
                        if (selectedContacts != null) {
                            MainActivity.this.selectedContacts = selectedContacts.toArray(new Contact[0]);
                            updateSelectedContactsDisplay();
                            Toast.makeText(MainActivity.this, 
                                    "已选择 " + selectedContacts.size() + " 个联系人", 
                                    Toast.LENGTH_SHORT).show();
                        }
                    }
                }
        );
        if (getSupportFragmentManager() != null) {
            dialog.show(getSupportFragmentManager(), "SelectedContactsBottomSheet");
        }
    }

    private void updateSelectedTemplateDisplay() {
        if (selectedTemplate != null) {
            String title = selectedTemplate.getTitle() != null ? selectedTemplate.getTitle() : "未知";
            String content = selectedTemplate.getContent() != null ? selectedTemplate.getContent() : "";
            
            // 显示格式内容区域
            if (llSelectedTemplateContent != null) {
                llSelectedTemplateContent.setVisibility(View.VISIBLE);
            }
            if (tvSelectedTemplateTitle != null) {
                tvSelectedTemplateTitle.setText(title);
            }
            if (tvSelectedTemplateContent != null) {
                // 如果内容过长，截取前100个字符并添加省略号
                if (content.length() > 100) {
                    tvSelectedTemplateContent.setText(content.substring(0, 100) + "...");
                } else {
                    tvSelectedTemplateContent.setText(content);
                }
            }
        } else {
            // 隐藏格式内容区域
            if (llSelectedTemplateContent != null) {
                llSelectedTemplateContent.setVisibility(View.GONE);
            }
        }
    }

    private boolean isEmulator() {
        return Build.FINGERPRINT.startsWith("generic")
                || Build.FINGERPRINT.startsWith("unknown")
                || Build.MODEL.contains("google_sdk")
                || Build.MODEL.contains("Emulator")
                || Build.MODEL.contains("Android SDK built for x86")
                || Build.MANUFACTURER.contains("Genymotion")
                || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
                || "google_sdk".equals(Build.PRODUCT)
                || Build.HARDWARE.contains("goldfish")
                || Build.HARDWARE.contains("ranchu");
    }

    /**
     * 获取 SMS 发送结果码的详细说明
     * 注意：RESULT_OK 只表示发送请求被系统接受，不代表短信真正发送成功
     * 如果短信中心号码未配置，即使返回 RESULT_OK，短信也可能未实际发送
     */
    private String getSmsResultCodeMessage(int resultCode) {
        switch (resultCode) {
            case Activity.RESULT_OK:
                return "发送请求已接受（注意：这不代表短信已真正发送，请检查短信中心号码是否配置）";
            case 1: // RESULT_ERROR_GENERIC_FAILURE
                return "通用失败（可能是SIM卡问题、短信中心号码未配置、无网络信号等）";
            case 2: // RESULT_ERROR_RADIO_OFF
                return "无线电关闭（飞行模式或SIM卡未激活）";
            case 3: // RESULT_ERROR_NULL_PDU
                return "空PDU（协议数据单元错误）";
            case 4: // RESULT_ERROR_NO_SERVICE
                return "无服务（无网络信号或SIM卡问题）";
            default:
                return "未知错误码: " + resultCode;
        }
    }

    /**
     * 诊断短信发送环境，检查 SIM 卡状态、短信中心号码等
     */
    private void diagnoseSmsEnvironment() {
        Log.d(TAG, "=== 开始诊断短信发送环境 ===");
        
        try {
            TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            if (telephonyManager == null) {
                Log.e(TAG, "诊断: TelephonyManager 不可用");
                return;
            }

            // 检查 SIM 卡状态
            int simState = telephonyManager.getSimState();
            String simStateStr = getSimStateString(simState);
            Log.d(TAG, "SIM 卡状态: " + simStateStr + " (code=" + simState + ")");
            
            if (simState != TelephonyManager.SIM_STATE_READY) {
                Log.w(TAG, "诊断: SIM 卡未就绪！这是导致发送失败的主要原因");
            }

            // 检查网络类型
            int networkType = telephonyManager.getNetworkType();
            String networkTypeStr = getNetworkTypeString(networkType);
            Log.d(TAG, "网络类型: " + networkTypeStr + " (code=" + networkType + ")");

            // 检查电话状态
            int callState = telephonyManager.getCallState();
            String callStateStr = getCallStateString(callState);
            Log.d(TAG, "电话状态: " + callStateStr + " (code=" + callState + ")");

            // 检查是否有 SIM 卡（使用getSimState作为主要判断依据，更可靠）
            boolean hasIccCard = (simState == TelephonyManager.SIM_STATE_READY);
            Log.d(TAG, "是否有 SIM 卡（基于SIM状态）: " + hasIccCard);
            
            // 额外检查：尝试通过SubscriptionManager验证（如果权限允许）
            try {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                            == PackageManager.PERMISSION_GRANTED) {
                        SubscriptionManager subManager = SubscriptionManager.from(this);
                        if (subManager != null) {
                            List<SubscriptionInfo> subList = subManager.getActiveSubscriptionInfoList();
                            if (subList != null && !subList.isEmpty()) {
                                Log.d(TAG, "检测到 " + subList.size() + " 个活跃的SIM卡订阅");
                                for (SubscriptionInfo info : subList) {
                                    Log.d(TAG, "  - SIM卡 ID: " + info.getSubscriptionId() + 
                                          ", 运营商: " + info.getCarrierName());
                                }
                            } else {
                                Log.w(TAG, "SubscriptionManager未检测到活跃的SIM卡订阅（可能与实际SIM状态不一致）");
                            }
                        }
                    }
                }
            } catch (Exception e) {
                Log.w(TAG, "诊断: 无法通过SubscriptionManager检查SIM卡", e);
            }

            // 检查短信中心号码（需要 READ_PHONE_STATE 权限）
            try {
                if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                        == PackageManager.PERMISSION_GRANTED) {
                    SmsManager smsManager = getSmsManager();
                    if (smsManager != null) {
                        // 注意：getSmscAddress() 在 API 22+ 可用，但在某些旧设备或定制ROM上可能不存在
                        // 使用反射安全调用，避免 NoSuchMethodError
                        try {
                            java.lang.reflect.Method getSmscMethod = smsManager.getClass().getMethod("getSmscAddress");
                            String smscAddress = (String) getSmscMethod.invoke(smsManager);
                            if (smscAddress != null && !smscAddress.isEmpty()) {
                                Log.d(TAG, "短信中心号码: " + smscAddress);
                            } else {
                                Log.w(TAG, "诊断: 短信中心号码为空或未配置！这可能是导致发送失败的主要原因");
                            }
                        } catch (NoSuchMethodException e) {
                            Log.w(TAG, "诊断: 设备不支持 getSmscAddress() 方法（可能是旧版本Android或定制ROM）");
                        } catch (java.lang.reflect.InvocationTargetException e) {
                            // 如果反射调用时抛出异常，可能是权限问题或其他运行时错误
                            Throwable cause = e.getCause();
                            if (cause instanceof SecurityException) {
                                Log.w(TAG, "诊断: 权限不足，无法获取短信中心号码（系统限制，但短信发送不受影响）");
                            } else {
                                Log.w(TAG, "诊断: 无法获取短信中心号码", cause);
                            }
                        }
                    }
                } else {
                    Log.w(TAG, "诊断: 缺少 READ_PHONE_STATE 权限，无法检查短信中心号码");
                }
            } catch (SecurityException e) {
                // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                // 这种情况下短信通常仍能正常发送，在诊断中只记录简要信息
                Log.w(TAG, "诊断: 权限不足，无法获取短信中心号码（系统限制，但短信发送不受影响）");
            } catch (Exception e) {
                Log.w(TAG, "诊断: 无法获取短信中心号码（可能不支持此功能）", e);
            } catch (NoSuchMethodError e) {
                // 某些旧设备在编译时方法存在，但运行时不存在，捕获此错误
                Log.w(TAG, "诊断: 设备不支持 getSmscAddress() 方法（NoSuchMethodError）");
            }

            // 检查设备型号和制造商
            Log.d(TAG, "设备制造商: " + Build.MANUFACTURER);
            Log.d(TAG, "设备型号: " + Build.MODEL);
            Log.d(TAG, "Android 版本: " + Build.VERSION.RELEASE);
            
            // 检查是否是MIUI系统（小米/红米设备）
            boolean isMiui = isMiuiSystem();
            if (isMiui) {
                Log.w(TAG, "诊断: 检测到MIUI系统，可能需要额外的系统权限");
                Log.w(TAG, "  - 建议：检查是否授予了'后台弹出界面'权限");
                Log.w(TAG, "  - 建议：检查是否授予了'自启动'权限");
                Log.w(TAG, "  - 建议：某些MIUI版本可能要求应用是默认短信应用");
            }
            
            // 检查是否是默认短信应用（某些系统可能需要）
            try {
                String defaultSmsPackage = null;
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    defaultSmsPackage = android.provider.Telephony.Sms.getDefaultSmsPackage(this);
                }
                boolean isDefaultSmsApp = isDefaultSmsApp();
                Log.d(TAG, "当前默认短信应用: " + (defaultSmsPackage != null ? defaultSmsPackage : "未知"));
                Log.d(TAG, "本应用是否为默认短信应用: " + isDefaultSmsApp);
                if (!isDefaultSmsApp && isMiui) {
                    Log.w(TAG, "诊断: MIUI系统下，非默认短信应用可能无法发送短信");
                    Log.w(TAG, "  - 解决方案：在系统设置中将本应用设置为默认短信应用");
                }
            } catch (Exception e) {
                Log.w(TAG, "诊断: 无法检查默认短信应用", e);
            }
            
            // 检查是否是模拟器
            if (isEmulator()) {
                Log.w(TAG, "诊断: 检测到运行在模拟器上，短信可能无法真正发送");
            }

        } catch (Exception e) {
            Log.e(TAG, "诊断: 诊断过程中出现异常", e);
        }
        
        Log.d(TAG, "=== 诊断完成 ===");
    }

    private String getSimStateString(int state) {
        switch (state) {
            case TelephonyManager.SIM_STATE_ABSENT:
                return "SIM卡不存在";
            case TelephonyManager.SIM_STATE_PIN_REQUIRED:
                return "需要PIN码";
            case TelephonyManager.SIM_STATE_PUK_REQUIRED:
                return "需要PUK码";
            case TelephonyManager.SIM_STATE_NETWORK_LOCKED:
                return "网络锁定";
            case TelephonyManager.SIM_STATE_READY:
                return "SIM卡就绪";
            default:
                return "未知状态";
        }
    }

    private String getNetworkTypeString(int type) {
        switch (type) {
            case TelephonyManager.NETWORK_TYPE_UNKNOWN:
                return "未知";
            case TelephonyManager.NETWORK_TYPE_GPRS:
                return "GPRS";
            case TelephonyManager.NETWORK_TYPE_EDGE:
                return "EDGE";
            case TelephonyManager.NETWORK_TYPE_UMTS:
                return "UMTS";
            case TelephonyManager.NETWORK_TYPE_CDMA:
                return "CDMA";
            case TelephonyManager.NETWORK_TYPE_EVDO_0:
                return "EVDO_0";
            case TelephonyManager.NETWORK_TYPE_EVDO_A:
                return "EVDO_A";
            case TelephonyManager.NETWORK_TYPE_1xRTT:
                return "1xRTT";
            case TelephonyManager.NETWORK_TYPE_HSDPA:
                return "HSDPA";
            case TelephonyManager.NETWORK_TYPE_HSUPA:
                return "HSUPA";
            case TelephonyManager.NETWORK_TYPE_HSPA:
                return "HSPA";
            case TelephonyManager.NETWORK_TYPE_IDEN:
                return "IDEN";
            case TelephonyManager.NETWORK_TYPE_EVDO_B:
                return "EVDO_B";
            case TelephonyManager.NETWORK_TYPE_LTE:
                return "LTE";
            case TelephonyManager.NETWORK_TYPE_EHRPD:
                return "EHRPD";
            case TelephonyManager.NETWORK_TYPE_HSPAP:
                return "HSPAP";
            default:
                return "其他 (" + type + ")";
        }
    }

    private String getCallStateString(int state) {
        switch (state) {
            case TelephonyManager.CALL_STATE_IDLE:
                return "空闲";
            case TelephonyManager.CALL_STATE_RINGING:
                return "响铃";
            case TelephonyManager.CALL_STATE_OFFHOOK:
                return "通话中";
            default:
                return "未知";
        }
    }

    private void registerSmsReceivers() {
        smsSentReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                int resultCode = getResultCode();
                String errorMsg = getSmsResultCodeMessage(resultCode);
                String phoneNumber = intent.getStringExtra("phone_number");
                
                Log.d(TAG, "smsSentReceiver: 收到发送结果，resultCode=" + resultCode + 
                      (phoneNumber != null ? ", phoneNumber=" + phoneNumber : "") + 
                      ", error=" + errorMsg);
                
                // 更新对应联系人的状态
                if (phoneNumber != null) {
                    for (SendingStatus status : sendingStatusList) {
                        if (phoneNumber.equals(status.getPhoneNumber())) {
                            boolean wasCompleted = (status.getStatus() == SendingStatus.STATUS_SUCCESS || 
                                                  status.getStatus() == SendingStatus.STATUS_FAILED);
                
                if (resultCode == Activity.RESULT_OK) {
                    // 检查是否是长短信的分片
                                int partIndex = intent.getIntExtra("part_index", -1);
                                int totalParts = intent.getIntExtra("total_parts", -1);
                                if (partIndex >= 0 && totalParts > 1) {
                                    status.setPartIndex(partIndex);
                                    status.setTotalParts(totalParts);
                                    // 只有最后一个分片成功，才标记为成功
                                    if (partIndex == totalParts - 1) {
                                        status.setStatus(SendingStatus.STATUS_SUCCESS);
                                        // 只有状态从非完成变为完成时，才增加计数
                                        if (!wasCompleted) {
                                            successCount++;
                                        }
                                    }
                                } else {
                                    // 单条短信，直接标记为成功
                                    status.setStatus(SendingStatus.STATUS_SUCCESS);
                                    // 只有状态从非完成变为完成时，才增加计数
                                    if (!wasCompleted) {
                                        successCount++;
                                    }
                                }
                            } else {
                                // 发送失败，立即标记为失败（长短信的任意分片失败都算失败）
                                status.setStatus(SendingStatus.STATUS_FAILED);
                                status.setErrorMsg(errorMsg);
                                // 只有状态从非完成变为完成时，才增加计数
                                if (!wasCompleted) {
                                    failCount++;
                                }
                            }
                            break;
                        }
                    }
                }
                
                // 记录日志
                    int partIndex = intent.getIntExtra("part_index", -1);
                    int totalParts = intent.getIntExtra("total_parts", -1);
                    String partInfo = "";
                    if (partIndex >= 0 && totalParts > 1) {
                        partInfo = " [分片 " + (partIndex + 1) + "/" + totalParts + "]";
                    }
                
                if (resultCode == Activity.RESULT_OK) {
                    // 检查是否是MIUI系统且不是默认短信应用
                    boolean isMiui = isMiuiSystem();
                    boolean isDefaultSmsApp = isDefaultSmsApp();
                    
                    if (isMiui && !isDefaultSmsApp) {
                        Log.w(TAG, "smsSentReceiver: ⚠️ MIUI系统警告 - 虽然系统返回成功，但非默认短信应用可能无法真正发送短信！");
                        Log.w(TAG, "smsSentReceiver: 建议：在系统设置中将本应用设置为默认短信应用，否则短信可能无法发送");
                        // 在UI上显示警告（通过Toast或状态更新）
                        if (phoneNumber != null) {
                            runOnUiThread(() -> {
                                Toast.makeText(MainActivity.this, 
                                    "⚠️ MIUI系统：非默认短信应用可能无法发送，请检查是否真正收到", 
                                    Toast.LENGTH_LONG).show();
                            });
                        }
                    }
                    
                    Log.i(TAG, "smsSentReceiver: 短信分片发送成功" + partInfo + 
                          (phoneNumber != null ? ", phoneNumber=" + phoneNumber : "") +
                          " (联系人成功数: " + successCount + "/" + sendingStatusList.size() + ")");
                } else {
                    Log.e(TAG, "smsSentReceiver: 短信分片发送失败" + partInfo + 
                          ", resultCode=" + resultCode + ", error=" + errorMsg + 
                          (phoneNumber != null ? ", phoneNumber=" + phoneNumber : "") +
                          " (联系人失败数: " + failCount + "/" + sendingStatusList.size() + ")");
                }
                
                // 更新UI
                runOnUiThread(() -> updateProgressUI());
                
                // 检查是否所有联系人已完成
                boolean allContactsCompleted = true;
                for (SendingStatus status : sendingStatusList) {
                    if (status.getStatus() == SendingStatus.STATUS_PENDING || 
                        status.getStatus() == SendingStatus.STATUS_SENDING) {
                        allContactsCompleted = false;
                        break;
                    }
                }
                
                // 所有联系人发送完成（基于联系人计数，而不是分片）
                if (allContactsCompleted) {
                    // 保存resultCode用于延迟回调
                    final int finalResultCode = resultCode;
                    runOnUiThread(() -> {
                        // 延迟2秒后重置，让用户看到最终结果
                        new Handler(Looper.getMainLooper()).postDelayed(() -> {
                            // 先重新统计成功和失败数量（基于联系人状态，更准确）
                            // 必须在resetSendState()之前统计，因为resetSendState()会清空sendingStatusList
                            int finalSuccessCount = 0;
                            int finalFailCount = 0;
                            List<FailedContact> failedContacts = new ArrayList<>();
                            List<ContactInfo> successContacts = new ArrayList<>();
                            for (SendingStatus status : sendingStatusList) {
                                if (status.getStatus() == SendingStatus.STATUS_SUCCESS) {
                                    finalSuccessCount++;
                                    // 收集成功联系人详情
                                    ContactInfo successContact = new ContactInfo();
                                    successContact.setPhoneNumber(status.getPhoneNumber());
                                    successContact.setContactName(status.getContactName());
                                    successContacts.add(successContact);
                                } else if (status.getStatus() == SendingStatus.STATUS_FAILED) {
                                    finalFailCount++;
                                    // 收集失败详情
                                    FailedContact failedContact = new FailedContact();
                                    failedContact.setPhoneNumber(status.getPhoneNumber());
                                    failedContact.setContactName(status.getContactName());
                                    failedContact.setErrorMessage(status.getErrorMsg());
                                    failedContacts.add(failedContact);
                                }
                            }
                            String message = "批量发送完成！成功：" + finalSuccessCount + "，失败：" + finalFailCount;
                            
                            // 检查短信中心号码是否配置（即使发送返回成功，也可能因为短信中心号码未配置而实际未发送）
                            boolean smscConfigured = checkSmscAddress();
                            boolean hasSmscWarning = !smscConfigured && finalSuccessCount > 0;
                            String smscAddress = getSmscAddressString();
                            
                            // 创建并保存发送记录
                            createAndSaveSendRecord(finalSuccessCount, finalFailCount, failedContacts, successContacts, smscAddress, smscConfigured);
                            
                            // 统计完成后再重置发送状态
                            resetSendState();
                            
                            // 全部失败且resultCode=1时，提供详细的解决方案
                            if (finalFailCount > 0 && finalSuccessCount == 0 && finalResultCode == 1) {
                                boolean isMiui = isMiuiSystem();
                                
                                String detailedError = "所有短信发送失败！\n";
                                if (isMiui) {
                                    detailedError += "MIUI系统常见原因：\n";
                                    detailedError += "1. 短信中心号码未配置（联系运营商）\n";
                                    detailedError += "2. 需要授予'后台弹出界面'权限\n";
                                    detailedError += "3. 需要授予'自启动'权限\n";
                                    detailedError += "4. 某些MIUI版本要求应用是默认短信应用";
                                } else {
                                    detailedError += "可能原因：\n";
                                    detailedError += "1. 短信中心号码未配置（联系运营商）\n";
                                    detailedError += "2. SIM卡未就绪或网络信号差\n";
                                    detailedError += "3. 运营商限制或SIM卡问题";
                                }
                                detailedError += "\n请查看Logcat中的诊断信息";
                                Toast.makeText(MainActivity.this, detailedError, Toast.LENGTH_LONG).show();
                            } else if (finalFailCount > 0) {
                                // 部分失败或其他错误
                                boolean isMiui = isMiuiSystem();
                                boolean isDefaultSmsApp = isDefaultSmsApp();
                                
                                StringBuilder errorMessage = new StringBuilder(message);
                                errorMessage.append("\n请查看Logcat中的诊断信息");
                                if (isMiui && !isDefaultSmsApp && finalSuccessCount > 0) {
                                    errorMessage.append("\n\n⚠️ MIUI系统：非默认短信应用，" + 
                                                      "即使显示成功也可能未真正发送，请检查是否收到");
                                }
                                Toast.makeText(MainActivity.this, errorMessage.toString(), Toast.LENGTH_LONG).show();
                            } else {
                                // 全部成功，但需要检查短信中心号码警告和MIUI系统警告
                                boolean isMiui = isMiuiSystem();
                                boolean isDefaultSmsApp = isDefaultSmsApp();
                                
                                if (hasSmscWarning || (isMiui && !isDefaultSmsApp)) {
                                    StringBuilder warningMessage = new StringBuilder(message);
                                    warningMessage.append("\n\n⚠️ 重要警告：");
                                    if (hasSmscWarning) {
                                        warningMessage.append("\n短信中心号码可能未配置！");
                                    }
                                    if (isMiui && !isDefaultSmsApp) {
                                        if (hasSmscWarning) {
                                            warningMessage.append("\n");
                                        }
                                        warningMessage.append("MIUI系统：非默认短信应用可能无法发送！");
                                    }
                                    warningMessage.append("\n即使显示成功，短信可能未实际发送。");
                                    if (isMiui && !isDefaultSmsApp) {
                                        warningMessage.append("\n建议：在系统设置中将本应用设置为默认短信应用。");
                                    }
                                    if (hasSmscWarning) {
                                        warningMessage.append("\n请检查手机短信设置或联系运营商。");
                                    }
                                    Toast.makeText(MainActivity.this, warningMessage.toString(), Toast.LENGTH_LONG).show();
                                    if (hasSmscWarning) {
                                        Log.w(TAG, "发送完成但短信中心号码未配置，短信可能未实际发送");
                                    }
                                    if (isMiui && !isDefaultSmsApp) {
                                        Log.w(TAG, "发送完成但MIUI系统非默认短信应用，短信可能未实际发送");
                                    }
                                } else {
                                    Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
                                }
                            }
                            
                            // 即使在其他情况下，如果短信中心号码未配置，也记录警告到日志
                            if (hasSmscWarning) {
                                Log.w(TAG, "⚠️ 警告：短信中心号码可能未配置，即使显示成功，短信可能未实际发送！");
                            }
                        Log.i(TAG, message);
                        }, 2000); // 延迟2秒
                    });
                }
            }
        };

        smsDeliveredReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                int resultCode = getResultCode();
                String phoneNumber = intent.getStringExtra("phone_number");
                
                // 送达结果码的含义
                String deliveredStatus;
                switch (resultCode) {
                    case Activity.RESULT_OK:
                        deliveredStatus = "已送达";
                        break;
                    case 1: // RESULT_ERROR_GENERIC_FAILURE
                        deliveredStatus = "送达失败（通用错误）";
                        break;
                    case 2: // RESULT_ERROR_RADIO_OFF
                        deliveredStatus = "送达失败（无线电关闭）";
                        break;
                    case 3: // RESULT_ERROR_NULL_PDU
                        deliveredStatus = "送达失败（空PDU）";
                        break;
                    case 4: // RESULT_ERROR_NO_SERVICE
                        deliveredStatus = "送达失败（无服务）";
                        break;
                    default:
                        deliveredStatus = "送达状态未知: " + resultCode;
                        break;
                }
                
                Log.d(TAG, "smsDeliveredReceiver: 收到送达结果，resultCode=" + resultCode + 
                      ", status=" + deliveredStatus + 
                      (phoneNumber != null ? ", phoneNumber=" + phoneNumber : ""));
                
                // 如果送达失败，记录警告（但不影响发送成功的判断，因为发送成功和送达成功是两回事）
                if (resultCode != Activity.RESULT_OK && phoneNumber != null) {
                    Log.w(TAG, "smsDeliveredReceiver: 短信可能未送达 " + phoneNumber + "，状态: " + deliveredStatus);
                }
            }
        };

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            registerReceiver(smsSentReceiver, new IntentFilter(SMS_SENT_ACTION), Context.RECEIVER_NOT_EXPORTED);
            registerReceiver(smsDeliveredReceiver, new IntentFilter(SMS_DELIVERED_ACTION), Context.RECEIVER_NOT_EXPORTED);
        } else {
            registerReceiver(smsSentReceiver, new IntentFilter(SMS_SENT_ACTION));
            registerReceiver(smsDeliveredReceiver, new IntentFilter(SMS_DELIVERED_ACTION));
        }
        Log.d(TAG, "registerSmsReceivers: 广播接收器已注册");
    }

    @Override
    protected void onSaveInstanceState(@NonNull Bundle outState) {
        super.onSaveInstanceState(outState);
        Log.d(TAG, "onSaveInstanceState: 保存Activity状态");
        
        // 保存选中的联系人
        if (selectedContacts != null && selectedContacts.length > 0) {
            ArrayList<Contact> contactsList = new ArrayList<>(Arrays.asList(selectedContacts));
            outState.putSerializable("selectedContacts", contactsList);
            Log.d(TAG, "onSaveInstanceState: 保存了 " + contactsList.size() + " 个选中联系人");
        }
        
        // 保存选中的模板
        if (selectedTemplate != null) {
            outState.putSerializable("selectedTemplate", selectedTemplate);
            Log.d(TAG, "onSaveInstanceState: 保存了选中的模板 - " + selectedTemplate.getTitle());
        }
        
        // 保存短信内容
        if (etMessage != null && etMessage.getText() != null) {
            String messageText = etMessage.getText().toString();
            if (!messageText.isEmpty()) {
                outState.putString("messageText", messageText);
                Log.d(TAG, "onSaveInstanceState: 保存了短信内容");
            }
        }
        
        // 保存称谓相关状态
        outState.putBoolean("addGreeting", addGreeting);
        if (selectedGreeting != null) {
            outState.putString("selectedGreeting", selectedGreeting);
        }
    }
    
    /**
     * 恢复保存的状态
     */
    private void restoreInstanceState(Bundle savedInstanceState) {
        Log.d(TAG, "restoreInstanceState: 恢复Activity状态");
        
        // 恢复选中的联系人
        @SuppressWarnings("unchecked")
        ArrayList<Contact> savedContacts = (ArrayList<Contact>) savedInstanceState.getSerializable("selectedContacts");
        if (savedContacts != null && !savedContacts.isEmpty()) {
            selectedContacts = savedContacts.toArray(new Contact[0]);
            Log.d(TAG, "restoreInstanceState: 恢复了 " + selectedContacts.length + " 个选中联系人");
        }
        
        // 恢复选中的模板
        SmsTemplate savedTemplate = (SmsTemplate) savedInstanceState.getSerializable("selectedTemplate");
        if (savedTemplate != null) {
            selectedTemplate = savedTemplate;
            Log.d(TAG, "restoreInstanceState: 恢复了选中的模板 - " + selectedTemplate.getTitle());
        }
        
        // 恢复短信内容
        String savedMessageText = savedInstanceState.getString("messageText");
        if (savedMessageText != null && !savedMessageText.isEmpty() && etMessage != null) {
            etMessage.setText(savedMessageText);
            Log.d(TAG, "restoreInstanceState: 恢复了短信内容");
        }
        
        // 恢复称谓相关状态
        addGreeting = savedInstanceState.getBoolean("addGreeting", false);
        if (switchAddGreeting != null) {
            switchAddGreeting.setChecked(addGreeting);
        }
        if (llGreetingOptions != null) {
            llGreetingOptions.setVisibility(addGreeting ? View.VISIBLE : View.GONE);
        }
        String savedGreeting = savedInstanceState.getString("selectedGreeting");
        if (savedGreeting != null && chipGroupGreeting != null) {
            selectedGreeting = savedGreeting;
            // 尝试找到对应的Chip并选中
            for (int i = 0; i < chipGroupGreeting.getChildCount(); i++) {
                View child = chipGroupGreeting.getChildAt(i);
                if (child instanceof Chip) {
                    Chip chip = (Chip) child;
                    if (savedGreeting.equals(chip.getText().toString())) {
                        chip.setChecked(true);
                        break;
                    }
                }
            }
        }
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        // singleTop 模式下，如果 Activity 已在栈顶，会调用此方法而不是 onCreate
        // 这里可以处理新的 Intent，但通常从子 Activity 返回时不需要特殊处理
        setIntent(intent);
        Log.d(TAG, "onNewIntent: MainActivity 已存在，复用现有实例");
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 应用恢复时检查权限状态，确保按钮状态正确
        // 如果用户从设置中手动授予了权限，这里会正确更新按钮状态
        updateSendButtonState();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        
        // 清理Handler的延迟任务，防止内存泄漏
        if (sendHandler != null) {
            sendHandler.removeCallbacksAndMessages(null);
            Log.d(TAG, "onDestroy: 已清理Handler的延迟任务");
        }
        
        if (smsSentReceiver != null) {
            try {
                unregisterReceiver(smsSentReceiver);
            } catch (Exception e) {
                Log.e(TAG, "onDestroy: 注销smsSentReceiver失败", e);
            }
        }
        if (smsDeliveredReceiver != null) {
            try {
                unregisterReceiver(smsDeliveredReceiver);
            } catch (Exception e) {
                Log.e(TAG, "onDestroy: 注销smsDeliveredReceiver失败", e);
            }
        }
    }

    /**
     * 根据权限状态更新发送按钮的状态
     */
    private void updateSendButtonState() {
        if (btnSendSMS != null) {
            // 根据是否有权限来启用/禁用按钮（可选）
            // 这里我们选择不禁用按钮，而是让用户在点击时请求权限
            // 这样用户体验更好，不会因为权限被拒绝而永久禁用按钮
            // btnSendSMS.setEnabled(checkSmsPermission());
        }
    }

    private boolean checkSmsPermission() {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.SEND_SMS)
                == PackageManager.PERMISSION_GRANTED;
    }

    private void sendSMS() {
        Log.d(TAG, "sendSMS: 开始发送短信");
        
        // 防止重复发送
        if (isSending) {
            Log.w(TAG, "sendSMS: 正在发送中，忽略重复请求");
            Toast.makeText(this, "正在发送短信，请勿重复点击", Toast.LENGTH_SHORT).show();
            return;
        }
        
        String message = etMessage.getText().toString().trim();
        
        if (message.isEmpty()) {
            Toast.makeText(this, "请输入短信内容", Toast.LENGTH_SHORT).show();
            return;
        }

        // 获取要发送的手机号列表
        List<String> phoneNumbers = new ArrayList<>();
        
        if (selectedContacts.length > 0) {
            // 批量发送模式：使用选中的联系人
            for (Contact contact : selectedContacts) {
                String phoneNumber = contact.getPhoneNumber();
                if (phoneNumber != null && !phoneNumber.trim().isEmpty()) {
                    phoneNumbers.add(phoneNumber);
                }
            }
            Log.d(TAG, "sendSMS: 批量发送模式，共 " + phoneNumbers.size() + " 个联系人");
        } else {
            // 单个发送模式：使用手动输入的手机号
            String phoneNumber = etPhoneNumber.getText().toString().trim();
            if (phoneNumber.isEmpty()) {
                Toast.makeText(this, "请选择联系人或输入手机号码", Toast.LENGTH_SHORT).show();
                return;
            }
            phoneNumbers.add(phoneNumber);
            Log.d(TAG, "sendSMS: 单个发送模式");
        }

        if (phoneNumbers.isEmpty()) {
            Toast.makeText(this, "请选择联系人或输入手机号码", Toast.LENGTH_SHORT).show();
            return;
        }

        // 检查权限：如果还没有权限，一次性请求所有需要的权限
        if (!checkSmsPermission()) {
            Log.d(TAG, "sendSMS: 没有权限，请求权限");
            // 如果已经在请求权限，忽略重复请求
            if (isRequestingPermission) {
                Log.d(TAG, "sendSMS: 权限请求正在进行中，忽略重复请求");
                Toast.makeText(this, "权限请求正在进行中，请稍候...", Toast.LENGTH_SHORT).show();
                return;
            }
            // 保存待发送的数据，权限授予后继续发送
            pendingPhoneNumbers = phoneNumbers;
            pendingMessage = message;
            isRequestingPermission = true;
            // 构建需要请求的权限列表（只请求未授予的权限）
            // 注意：由于已经通过 checkSmsPermission() 检查，SEND_SMS 肯定需要请求
            List<String> permissionsToRequest = new ArrayList<>();
            permissionsToRequest.add(Manifest.permission.SEND_SMS);
            // READ_PHONE_STATE 用于获取SIM卡信息，建议授予（但非必需）
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                    != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.READ_PHONE_STATE);
            }
            // 一次性请求所有需要的权限（只需用户确认一次）
            smsPermissionLauncher.launch(permissionsToRequest.toArray(new String[0]));
            return;
        }

        // 有权限，直接发送
        sendSMSInternal(phoneNumbers, message);
    }

    /**
     * 获取发送间隔（毫秒）
     */
    private long getSendInterval() {
        SharedPreferences prefs = getSharedPreferences(PREF_NAME, MODE_PRIVATE);
        return prefs.getLong(PREF_SEND_INTERVAL, DEFAULT_SEND_INTERVAL_MS);
    }

    /**
     * 设置发送间隔（毫秒）
     */
    public void setSendInterval(long intervalMs) {
        SharedPreferences prefs = getSharedPreferences(PREF_NAME, MODE_PRIVATE);
        prefs.edit().putLong(PREF_SEND_INTERVAL, intervalMs).apply();
        Log.d(TAG, "setSendInterval: 发送间隔设置为 " + intervalMs + " 毫秒");
    }

    /**
     * 显示设置对话框
     */
    private void showSettingsDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("发送设置");

        // 创建外层容器
        LinearLayout container = new LinearLayout(this);
        container.setOrientation(LinearLayout.VERTICAL);
        container.setPadding(32, 24, 32, 8);

        // 创建说明文本
        TextView messageView = new TextView(this);
        messageView.setText("设置批量发送短信的时间间隔（毫秒）：\n" +
                "• 默认值：1000毫秒（1秒）\n" +
                "• 建议值：500-3000毫秒\n" +
                "• 间隔太短可能被运营商限制\n" +
                "• 间隔太长会影响发送速度");
        messageView.setTextSize(14);
        messageView.setTextColor(0xFF666666);
        messageView.setPadding(0, 0, 0, 16);
        container.addView(messageView);

        // 创建TextInputLayout包装输入框（符合Material Design规范）
        TextInputLayout inputLayout = new TextInputLayout(this);
        inputLayout.setHint("发送间隔（毫秒）");
        inputLayout.setPadding(0, 0, 0, 0);

        final TextInputEditText input = new TextInputEditText(this);
        input.setInputType(android.text.InputType.TYPE_CLASS_NUMBER);
        long currentInterval = getSendInterval();
        input.setText(String.valueOf(currentInterval));
        inputLayout.addView(input);
        container.addView(inputLayout);

        builder.setView(container);

        builder.setPositiveButton("确定", null); // 设置为null，在onShow中处理

        builder.setNegativeButton("取消", null);
        builder.setNeutralButton("恢复默认", (d, which) -> {
            setSendInterval(DEFAULT_SEND_INTERVAL_MS);
            Toast.makeText(this, "已恢复为默认值 " + DEFAULT_SEND_INTERVAL_MS + " 毫秒", Toast.LENGTH_SHORT).show();
        });

        // 创建对话框
        AlertDialog dialog = builder.create();
        
        // 在对话框显示后，重写确定按钮的行为，以便验证输入
        dialog.setOnShowListener(d -> {
            dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(v -> {
                String inputText = input.getText().toString().trim();
                if (inputText.isEmpty()) {
                    inputLayout.setError("请输入发送间隔");
                    input.requestFocus();
                    return;
                }
                
                try {
                    long interval = Long.parseLong(inputText);
                    if (interval < 0) {
                        inputLayout.setError("间隔不能为负数");
                        input.requestFocus();
                        return;
                    } else if (interval > 60000) {
                        inputLayout.setError("间隔不能超过60秒");
                        input.requestFocus();
                        return;
                    } else {
                        setSendInterval(interval);
                        Toast.makeText(this, "发送间隔已设置为 " + interval + " 毫秒", Toast.LENGTH_SHORT).show();
                        dialog.dismiss();
                    }
                } catch (NumberFormatException e) {
                    inputLayout.setError("请输入有效的数字");
                    input.requestFocus();
                    return;
                }
            });
        });

        dialog.show();
    }

    /**
     * 获取可用的 SmsManager（支持多 SIM 卡）
     */
    private SmsManager getSmsManager() {
        try {
            // Android 5.1+ 支持多 SIM 卡
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
                SubscriptionManager subscriptionManager = SubscriptionManager.from(this);
                if (subscriptionManager != null) {
                    List<SubscriptionInfo> activeSubscriptions = subscriptionManager.getActiveSubscriptionInfoList();
                    if (activeSubscriptions != null && !activeSubscriptions.isEmpty()) {
                        // 优先使用第一个可用的 SIM 卡
                        SubscriptionInfo firstSubscription = activeSubscriptions.get(0);
                        int subscriptionId = firstSubscription.getSubscriptionId();
                        
                        // 记录SIM卡信息以便排查问题
                        String carrierName = firstSubscription.getCarrierName() != null ? 
                            firstSubscription.getCarrierName().toString() : "未知";
                        Log.d(TAG, "getSmsManager: 使用多SIM卡模式，subscriptionId=" + subscriptionId + 
                              ", carrier=" + carrierName);
                        
                        SmsManager smsManager = SmsManager.getSmsManagerForSubscriptionId(subscriptionId);
                        
                        // 验证SmsManager是否可用
                        if (smsManager == null) {
                            Log.w(TAG, "getSmsManager: 通过subscriptionId获取的SmsManager为null，回退到默认方式");
                            return SmsManager.getDefault();
                        }
                        
                        return smsManager;
                    } else {
                        Log.d(TAG, "getSmsManager: 没有检测到活动的SIM卡，使用默认SmsManager");
                    }
                } else {
                    Log.d(TAG, "getSmsManager: SubscriptionManager为null，使用默认SmsManager");
                }
            }
            // 回退到默认方式
            SmsManager smsManager = SmsManager.getDefault();
            Log.d(TAG, "getSmsManager: 使用默认SmsManager");
            
            // 验证SmsManager是否可用
            if (smsManager == null) {
                Log.e(TAG, "getSmsManager: 默认SmsManager也为null，可能是模拟器或设备不支持");
            }
            
            return smsManager;
        } catch (Exception e) {
            Log.e(TAG, "getSmsManager: 获取SmsManager失败，使用默认方式", e);
            return SmsManager.getDefault();
        }
    }

    /**
     * 检查短信中心号码是否配置
     * @return true 如果短信中心号码已配置，false 如果未配置或无法检查
     */
    private boolean checkSmscAddress() {
        try {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                    == PackageManager.PERMISSION_GRANTED) {
                SmsManager smsManager = getSmsManager();
                if (smsManager != null) {
                    try {
                        // 使用反射安全调用，避免在旧设备上出现 NoSuchMethodError
                        java.lang.reflect.Method getSmscMethod = smsManager.getClass().getMethod("getSmscAddress");
                        String smscAddress = (String) getSmscMethod.invoke(smsManager);
                        if (smscAddress != null && !smscAddress.trim().isEmpty()) {
                            Log.d(TAG, "checkSmscAddress: 短信中心号码已配置: " + smscAddress);
                            return true;
                        } else {
                            Log.w(TAG, "checkSmscAddress: 短信中心号码未配置");
                            return false;
                        }
                    } catch (NoSuchMethodException e) {
                        // 设备不支持此方法（可能是旧版本Android或定制ROM）
                        Log.d(TAG, "checkSmscAddress: 设备不支持 getSmscAddress() 方法");
                        return true; // 无法检查时，假设已配置，避免误报
                    } catch (java.lang.reflect.InvocationTargetException e) {
                        // 如果反射调用时抛出异常，可能是权限问题或其他运行时错误
                        Throwable cause = e.getCause();
                        if (cause instanceof SecurityException) {
                            // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                            // 这种情况下短信通常仍能正常发送，所以只记录简要信息，不记录堆栈
                            Log.d(TAG, "checkSmscAddress: 权限不足（系统限制），无法检查短信中心号码，但短信发送不受影响");
                            return true; // 无法检查时，假设已配置，避免误报
                        } else if (cause instanceof UnsupportedOperationException) {
                            // API 33+ 可能不支持此方法
                            Log.d(TAG, "checkSmscAddress: 设备不支持获取短信中心号码（API限制）");
                            return true; // 无法检查时，假设已配置，避免误报
                        } else {
                            Log.d(TAG, "checkSmscAddress: 获取短信中心号码时出错", cause);
                            return true; // 无法检查时，假设已配置，避免误报
                        }
                    } catch (SecurityException e) {
                        // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                        // 这种情况下短信通常仍能正常发送，所以只记录简要信息，不记录堆栈
                        Log.d(TAG, "checkSmscAddress: 权限不足（系统限制），无法检查短信中心号码，但短信发送不受影响");
                        return true; // 无法检查时，假设已配置，避免误报
                    } catch (UnsupportedOperationException e) {
                        // API 33+ 可能不支持此方法
                        Log.d(TAG, "checkSmscAddress: 设备不支持获取短信中心号码（API限制）");
                        return true; // 无法检查时，假设已配置，避免误报
                    } catch (NoSuchMethodError e) {
                        // 某些旧设备在编译时方法存在，但运行时不存在，捕获此错误
                        Log.d(TAG, "checkSmscAddress: 设备不支持 getSmscAddress() 方法（NoSuchMethodError）");
                        return true; // 无法检查时，假设已配置，避免误报
                    }
                }
            } else {
                Log.w(TAG, "checkSmscAddress: 缺少 READ_PHONE_STATE 权限，无法检查短信中心号码");
                return true; // 无法检查时，假设已配置，避免误报
            }
        } catch (Exception e) {
            Log.w(TAG, "checkSmscAddress: 检查短信中心号码时出错", e);
            return true; // 无法检查时，假设已配置，避免误报
        }
        return true; // 默认返回true，避免误报
    }
    
    /**
     * 获取短信中心号码
     * @return 短信中心号码字符串，如果无法获取则返回null
     */
    private String getSmscAddressString() {
        try {
            if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                    == PackageManager.PERMISSION_GRANTED) {
                SmsManager smsManager = getSmsManager();
                if (smsManager != null) {
                    try {
                        // 使用反射安全调用，避免在旧设备上出现 NoSuchMethodError
                        java.lang.reflect.Method getSmscMethod = smsManager.getClass().getMethod("getSmscAddress");
                        return (String) getSmscMethod.invoke(smsManager);
                    } catch (NoSuchMethodException e) {
                        // 设备不支持此方法（可能是旧版本Android或定制ROM）
                        Log.d(TAG, "getSmscAddressString: 设备不支持 getSmscAddress() 方法");
                        return null;
                    } catch (java.lang.reflect.InvocationTargetException e) {
                        // 如果反射调用时抛出异常，可能是权限问题或其他运行时错误
                        Throwable cause = e.getCause();
                        if (cause instanceof SecurityException) {
                            // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                            // 只记录简要信息，不记录堆栈，减少日志噪音
                            Log.d(TAG, "getSmscAddressString: 权限不足（系统限制），无法获取短信中心号码");
                            return null;
                        } else if (cause instanceof UnsupportedOperationException) {
                            return null;
                        } else {
                            Log.d(TAG, "getSmscAddressString: 获取短信中心号码时出错", cause);
                            return null;
                        }
                    } catch (SecurityException e) {
                        // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                        // 只记录简要信息，不记录堆栈，减少日志噪音
                        Log.d(TAG, "getSmscAddressString: 权限不足（系统限制），无法获取短信中心号码");
                        return null;
                    } catch (UnsupportedOperationException e) {
                        return null;
                    } catch (NoSuchMethodError e) {
                        // 某些旧设备在编译时方法存在，但运行时不存在，捕获此错误
                        Log.d(TAG, "getSmscAddressString: 设备不支持 getSmscAddress() 方法（NoSuchMethodError）");
                        return null;
                    }
                }
            }
        } catch (Exception e) {
            Log.w(TAG, "getSmscAddressString: 获取短信中心号码时出错", e);
        }
        return null;
    }
    
    /**
     * 检测是否是MIUI系统（小米/红米设备）
     * @return true 如果是MIUI系统
     */
    private boolean isMiuiSystem() {
        return Build.MANUFACTURER.equalsIgnoreCase("Xiaomi") || 
               Build.MANUFACTURER.equalsIgnoreCase("Redmi");
    }
    
    /**
     * 检测当前应用是否是默认短信应用
     * @return true 如果是默认短信应用
     */
    private boolean isDefaultSmsApp() {
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                String defaultSmsPackage = android.provider.Telephony.Sms.getDefaultSmsPackage(this);
                String currentPackage = getPackageName();
                return (defaultSmsPackage != null && defaultSmsPackage.equals(currentPackage));
            }
        } catch (Exception e) {
            // 忽略检查错误
            Log.d(TAG, "isDefaultSmsApp: 检查默认短信应用时出错", e);
        }
        return false;
    }
    
    /**
     * 创建并保存发送记录
     */
    private void createAndSaveSendRecord(int successCount, int failCount, List<FailedContact> failedContacts, 
                                         List<ContactInfo> successContacts, String smscAddress, boolean smscConfigured) {
        try {
            // 创建发送记录
            SmsSendRecord record = new SmsSendRecord();
            record.setTimestamp(System.currentTimeMillis());
            
            // 统计信息
            // totalContacts 应该是实际尝试发送的数量（成功+失败），而不是选中联系人的数量
            // 因为某些联系人可能因为格式问题等原因根本没有尝试发送
            int actualTotal = successCount + failCount;
            record.setTotalContacts(actualTotal > 0 ? actualTotal : (selectedContacts != null ? selectedContacts.length : 0));
            record.setSuccessCount(successCount);
            record.setFailCount(failCount);
            
            // 短信内容（使用保存的消息内容，因为etMessage可能在发送时已被清空）
            String messageContent = currentSendingMessage != null ? currentSendingMessage : "";
            record.setMessageContent(messageContent);
            
            // 模板信息
            if (selectedTemplate != null) {
                record.setTemplateId(selectedTemplate.getId());
                record.setTemplateName(selectedTemplate.getTitle());
            }
            
            // 联系人详情
            record.setSuccessContacts(successContacts);
            record.setFailedContacts(failedContacts);
            
            // 系统信息
            record.setSmscAddress(smscAddress);
            record.setSmscConfigured(smscConfigured);
            record.setDeviceInfo(Build.MANUFACTURER + " " + Build.MODEL);
            
            // 保存记录（在后台线程执行，避免阻塞UI）
            new Thread(() -> {
                try {
                    DataManager.getInstance(MainActivity.this).addSendRecord(record);
                    Log.d(TAG, "发送记录已保存: " + record.getDateTime() + ", 成功:" + successCount + ", 失败:" + failCount);
                } catch (Exception e) {
                    Log.e(TAG, "保存发送记录失败", e);
                }
            }).start();
        } catch (Exception e) {
            Log.e(TAG, "创建发送记录失败", e);
        }
    }
    
    /**
     * 验证短信发送环境（发送前的关键检查）
     */
    private boolean validateSmsEnvironment() {
        try {
            TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            if (telephonyManager == null) {
                Log.e(TAG, "validateSmsEnvironment: TelephonyManager 不可用");
                Toast.makeText(this, "无法获取电话服务，请检查设备状态", Toast.LENGTH_LONG).show();
                return false;
            }

            // 检查 SIM 卡状态
            int simState = telephonyManager.getSimState();
            if (simState != TelephonyManager.SIM_STATE_READY) {
                String stateStr = getSimStateString(simState);
                Log.e(TAG, "validateSmsEnvironment: SIM 卡未就绪，状态=" + stateStr);
                Toast.makeText(this, "SIM 卡未就绪（" + stateStr + "），无法发送短信", Toast.LENGTH_LONG).show();
                return false;
            }

            // 检查短信中心号码（如果可能）
            // 注意：某些设备可能无法获取短信中心号码，所以只作为警告，不阻止发送
            try {
                if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) 
                        == PackageManager.PERMISSION_GRANTED) {
                    SmsManager smsManager = getSmsManager();
                    if (smsManager != null) {
                        try {
                            // 使用反射安全调用，避免在旧设备上出现 NoSuchMethodError
                            java.lang.reflect.Method getSmscMethod = smsManager.getClass().getMethod("getSmscAddress");
                            String smscAddress = (String) getSmscMethod.invoke(smsManager);
                            if (smscAddress == null || smscAddress.trim().isEmpty()) {
                                Log.w(TAG, "validateSmsEnvironment: 短信中心号码未配置");
                                // 不直接阻止发送，因为某些设备可能无法获取，但记录警告到日志
                                // 用户可以通过诊断功能查看详细信息
                            } else {
                                Log.d(TAG, "validateSmsEnvironment: 短信中心号码已配置: " + smscAddress);
                            }
                        } catch (NoSuchMethodException e) {
                            // 设备不支持此方法（可能是旧版本Android或定制ROM）
                            Log.d(TAG, "validateSmsEnvironment: 设备不支持 getSmscAddress() 方法");
                        } catch (java.lang.reflect.InvocationTargetException e) {
                            // 如果反射调用时抛出异常，可能是权限问题或其他运行时错误
                            Throwable cause = e.getCause();
                            if (cause instanceof SecurityException) {
                                // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                                // 这种情况下短信通常仍能正常发送，所以只记录简要信息，不记录堆栈
                                Log.d(TAG, "validateSmsEnvironment: 权限不足（系统限制），无法检查短信中心号码，但短信发送不受影响");
                            } else if (cause instanceof UnsupportedOperationException) {
                                // API 33+ 可能不支持此方法
                                Log.d(TAG, "validateSmsEnvironment: 设备不支持获取短信中心号码（API限制）");
                            } else {
                                Log.d(TAG, "validateSmsEnvironment: 获取短信中心号码时出错", cause);
                            }
                        } catch (SecurityException e) {
                            // MIUI等系统可能需要系统级权限，即使有READ_PHONE_STATE也会抛出SecurityException
                            // 这种情况下短信通常仍能正常发送，所以只记录简要信息，不记录堆栈
                            Log.d(TAG, "validateSmsEnvironment: 权限不足（系统限制），无法检查短信中心号码，但短信发送不受影响");
                        } catch (UnsupportedOperationException e) {
                            // API 33+ 可能不支持此方法
                            Log.d(TAG, "validateSmsEnvironment: 设备不支持获取短信中心号码（API限制）");
                        } catch (NoSuchMethodError e) {
                            // 某些旧设备在编译时方法存在，但运行时不存在，捕获此错误
                            Log.d(TAG, "validateSmsEnvironment: 设备不支持 getSmscAddress() 方法（NoSuchMethodError）");
                        }
                    }
                }
            } catch (Exception e) {
                Log.w(TAG, "validateSmsEnvironment: 无法检查短信中心号码", e);
                // 不阻止发送，因为某些设备可能不支持此功能
            }

            return true;
        } catch (Exception e) {
            Log.e(TAG, "validateSmsEnvironment: 验证环境时出错", e);
            Toast.makeText(this, "环境检查失败: " + e.getMessage(), Toast.LENGTH_LONG).show();
            return false;
        }
    }

    /**
     * 实际发送短信的内部方法（已确保有权限）
     */
    private void sendSMSInternal(List<String> phoneNumbers, String message) {
        Log.d(TAG, "sendSMSInternal: 开始发送，共 " + phoneNumbers.size() + " 条短信");

        // 保存当前发送的消息内容（在发送完成后保存记录时使用）
        currentSendingMessage = message;

        // 设置发送状态，防止重复发送
        isSending = true;
        btnSendSMS.setEnabled(false);
        btnSendSMS.setText("发送中...");

        // 执行诊断，检查环境状态
        diagnoseSmsEnvironment();

        // 发送前验证环境
        if (!validateSmsEnvironment()) {
            Log.w(TAG, "sendSMSInternal: 环境验证失败，取消发送");
            resetSendState();
            return;
        }

        // 再次确认权限（双重检查，确保权限在检查后没有被撤销）
        if (!checkSmsPermission()) {
            Log.w(TAG, "sendSMSInternal: 权限检查失败");
            Toast.makeText(this, "短信发送权限未授予，无法发送", Toast.LENGTH_SHORT).show();
            // 清空待发送的数据，确保状态一致
            pendingPhoneNumbers = null;
            pendingMessage = null;
            resetSendState();
            return;
        }

        // 重置计数器（基于联系人计数）
        successCount = 0;
        failCount = 0;
        // totalSmsCount保留用于日志（基于分片计数）
        totalSmsCount = 0;
        
        // 初始化发送状态列表
        sendingStatusList.clear();
        for (String phoneNumber : phoneNumbers) {
            // 查找对应的联系人名称
            String contactName = null;
            if (selectedContacts != null && selectedContacts.length > 0) {
                for (Contact contact : selectedContacts) {
                    if (contact != null && phoneNumber.equals(contact.getPhoneNumber())) {
                        contactName = contact.getName();
                        break;
                    }
                }
            }
            SendingStatus status = new SendingStatus(phoneNumber, contactName);
            status.setStatus(SendingStatus.STATUS_PENDING);
            sendingStatusList.add(status);
        }
        
        // 显示进度卡片
        if (cardSendingProgress != null) {
            cardSendingProgress.setVisibility(View.VISIBLE);
        }
        
        // 初始化UI
        updateProgressUI();

        try {
            SmsManager smsManager = getSmsManager();
            
            if (smsManager == null) {
                Log.e(TAG, "sendSMSInternal: SmsManager 不可用（可能是模拟器）");
                Toast.makeText(this, "无法发送短信：SmsManager 不可用（可能需要在真机上测试）", Toast.LENGTH_LONG).show();
                resetSendState();
                return;
            }
            
            // 计算总的消息条数（考虑长短信拆分）
            // 对于长短信，每条会被拆分成多条，需要准确统计
            ArrayList<String> messageParts = smsManager.divideMessage(message);
            int partsPerMessage = messageParts.size();
            totalSmsCount = phoneNumbers.size() * partsPerMessage;
            
            long sendInterval = getSendInterval();
            Log.d(TAG, "sendSMSInternal: 开始批量发送，共 " + phoneNumbers.size() + " 个联系人，" +
                  "每条消息 " + partsPerMessage + " 条短信，总计 " + totalSmsCount + " 条短信，" +
                  "发送间隔 " + sendInterval + " 毫秒");
            
            // 详细记录短信分割情况
            if (partsPerMessage > 1) {
                Log.i(TAG, "sendSMSInternal: 短信内容过长（" + message.length() + " 字符），" +
                      "已自动分割成 " + partsPerMessage + " 条短信（中文短信每条最多70字符）");
                for (int i = 0; i < messageParts.size(); i++) {
                    Log.d(TAG, "sendSMSInternal: 第 " + (i + 1) + " 条分片长度: " + 
                          messageParts.get(i).length() + " 字符");
                }
            } else {
                Log.d(TAG, "sendSMSInternal: 短信内容 " + message.length() + " 字符，单条发送");
            }
            
            // 批量发送短信（带时间间隔，避免被运营商限制）
            // 使用Handler延迟发送，每条短信之间间隔指定时间
            final int totalCount = phoneNumbers.size();
            for (int i = 0; i < totalCount; i++) {
                final String phoneNumber = phoneNumbers.get(i);
                final int index = i;
                
                // 计算延迟时间（第一条立即发送，后续按间隔延迟）
                long delay = i * sendInterval;
                
                sendHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        // 再次确认权限状态（防止在发送过程中权限被撤销）
                        if (!checkSmsPermission()) {
                            Log.w(TAG, "sendSMSInternal: 发送过程中权限被撤销，停止发送");
                            Toast.makeText(MainActivity.this, "发送过程中权限被撤销，已停止发送", Toast.LENGTH_LONG).show();
                            return;
                        }
                        
                        Log.d(TAG, "sendSMSInternal: 发送第 " + (index + 1) + "/" + totalCount + " 条短信到 " + phoneNumber);
                        
                        // 更新状态为发送中
                        runOnUiThread(() -> {
                            for (SendingStatus status : sendingStatusList) {
                                if (phoneNumber.equals(status.getPhoneNumber())) {
                                    status.setStatus(SendingStatus.STATUS_SENDING);
                                    updateProgressUI();
                                    break;
                                }
                            }
                        });
                        
                        // 生成个性化短信内容（如果启用称谓）
                        String personalizedMessage = generatePersonalizedMessage(message, phoneNumber);
                        sendSingleSMS(smsManager, phoneNumber, personalizedMessage);
                    }
                }, delay);
            }
            
            Toast.makeText(this, "正在批量发送短信到 " + phoneNumbers.size() + " 个号码...", Toast.LENGTH_SHORT).show();
            
            // 清空输入框
            etMessage.setText("");
            etPhoneNumber.setText("");
            selectedContacts = new Contact[0];
            selectedTemplate = null;
            updateSelectedContactsDisplay();
            updateSelectedTemplateDisplay();
            
        } catch (Exception e) {
            Log.e(TAG, "sendSMSInternal: 发送失败", e);
            Toast.makeText(this, "发送失败: " + e.getMessage(), Toast.LENGTH_LONG).show();
            resetSendState();
        }
    }
    
    /**
     * 规范化手机号（移除空格、横线等非数字字符，用于比较）
     */
    private String normalizePhoneForComparison(String phoneNumber) {
        if (phoneNumber == null) {
            return "";
        }
        return phoneNumber.replaceAll("[^0-9]", "");
    }
    
    /**
     * 根据手机号获取联系人姓名
     * @param phoneNumber 手机号
     * @return 联系人姓名，如果找不到则返回 null
     */
    private String getContactName(String phoneNumber) {
        if (phoneNumber == null || phoneNumber.trim().isEmpty()) {
            return null;
        }
        
        // 规范化手机号用于比较（移除非数字字符）
        String normalizedPhone = normalizePhoneForComparison(phoneNumber);
        
        // 先从 selectedContacts 中查找
        if (selectedContacts != null && selectedContacts.length > 0) {
            for (Contact contact : selectedContacts) {
                if (contact != null) {
                    String contactPhone = contact.getPhoneNumber();
                    if (contactPhone != null && normalizedPhone.equals(normalizePhoneForComparison(contactPhone))) {
                        String name = contact.getName();
                        if (name != null && !name.trim().isEmpty()) {
                            return name.trim();
                        }
                    }
                }
            }
        }
        
        // 如果找不到，从 sendingStatusList 中查找（用于单个发送模式等场景）
        if (sendingStatusList != null) {
            for (SendingStatus status : sendingStatusList) {
                String statusPhone = status.getPhoneNumber();
                if (statusPhone != null && normalizedPhone.equals(normalizePhoneForComparison(statusPhone))) {
                    String name = status.getContactName();
                    if (name != null && !name.trim().isEmpty()) {
                        return name.trim();
                    }
                }
            }
        }
        
        return null;
    }
    
    /**
     * 生成个性化短信内容（如果启用称谓）
     * @param originalMessage 原始短信内容
     * @param phoneNumber 手机号
     * @return 个性化后的短信内容
     */
    private String generatePersonalizedMessage(String originalMessage, String phoneNumber) {
        if (!addGreeting || originalMessage == null) {
            return originalMessage;
        }
        
        String contactName = getContactName(phoneNumber);
        String greeting;
        
        if (contactName != null && !contactName.trim().isEmpty()) {
            // 使用联系人姓名 + 选择的称谓
            greeting = contactName + selectedGreeting;
        } else {
            // 如果找不到联系人姓名，使用手机号后4位
            // 先清理手机号中的非数字字符，确保正确提取后4位
            String cleanPhoneNumber = phoneNumber != null ? phoneNumber.replaceAll("[^0-9]", "") : "";
            if (cleanPhoneNumber.length() > 4) {
                String phoneSuffix = cleanPhoneNumber.substring(cleanPhoneNumber.length() - 4);
                greeting = phoneSuffix + selectedGreeting;
            } else if (cleanPhoneNumber.length() > 0) {
                // 如果手机号太短（但大于0），直接使用清理后的手机号
                greeting = cleanPhoneNumber + selectedGreeting;
            } else {
                // 如果手机号为空或无效，使用默认称谓
                greeting = "您" + selectedGreeting;
            }
        }
        
        return greeting + originalMessage;
    }
    
    /**
     * 创建通知渠道
     */
    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                    CHANNEL_ID,
                    "短信发送进度",
                    NotificationManager.IMPORTANCE_LOW
            );
            channel.setDescription("显示短信批量发送的进度");
            channel.setShowBadge(false);
            if (notificationManager != null) {
                notificationManager.createNotificationChannel(channel);
            }
        }
    }
    
    /**
     * 显示进度详情BottomSheet
     */
    private void showProgressBottomSheet() {
        if (sendingStatusList == null || sendingStatusList.isEmpty()) {
            return;
        }
        
        if (progressBottomSheet == null || !progressBottomSheet.isAdded()) {
            progressBottomSheet = SendingProgressBottomSheetDialog.newInstance(sendingStatusList);
            if (getSupportFragmentManager() != null) {
                progressBottomSheet.show(getSupportFragmentManager(), "SendingProgressBottomSheet");
                // 在 show() 之后设置对话框关闭监听，清理引用
                if (progressBottomSheet.getDialog() != null) {
                    progressBottomSheet.getDialog().setOnDismissListener(dialog -> {
                        if (progressBottomSheet != null && !progressBottomSheet.isAdded()) {
                            progressBottomSheet = null;
                        }
                    });
                }
            }
        } else {
            // 更新现有对话框
            progressBottomSheet.updateStatusList(sendingStatusList);
        }
    }
    
    /**
     * 更新进度UI
     */
    private void updateProgressUI() {
        if (sendingStatusList == null || sendingStatusList.isEmpty()) {
            return;
        }
        
        int total = sendingStatusList.size();
        int completed = 0;
        int success = 0;
        int failed = 0;
        int sending = 0;
        SendingStatus currentSending = null;
        
        for (SendingStatus status : sendingStatusList) {
            if (status.getStatus() == SendingStatus.STATUS_SUCCESS || 
                status.getStatus() == SendingStatus.STATUS_FAILED) {
                completed++;
            }
            if (status.getStatus() == SendingStatus.STATUS_SUCCESS) {
                success++;
            } else if (status.getStatus() == SendingStatus.STATUS_FAILED) {
                failed++;
            } else if (status.getStatus() == SendingStatus.STATUS_SENDING) {
                sending++;
                if (currentSending == null) {
                    currentSending = status;
                }
            }
        }
        
        // 更新进度条
        int progress = total > 0 ? (completed * 100 / total) : 0;
        progressBar.setProgress(progress);
        
        // 更新进度文本
        tvProgressText.setText(completed + "/" + total);
        
        // 更新当前发送信息
        if (currentSending != null) {
            String displayName = currentSending.getDisplayName();
            tvCurrentSending.setText("正在发送：" + displayName);
        } else if (completed >= total) {
            tvCurrentSending.setText("发送完成");
        } else {
            tvCurrentSending.setText("准备发送...");
        }
        
        // 更新统计信息
        tvProgressStats.setText("成功：" + success + " | 失败：" + failed);
        
        // 更新通知
        updateNotification(completed, total, success, failed, currentSending);
        
        // 更新BottomSheet（如果已打开）
        if (progressBottomSheet != null && progressBottomSheet.isAdded()) {
            progressBottomSheet.updateStatusList(sendingStatusList);
        } else if (progressBottomSheet != null) {
            // 如果对话框已关闭但引用还在，清理引用
            progressBottomSheet = null;
        }
    }
    
    /**
     * 更新通知栏进度
     */
    private void updateNotification(int completed, int total, int success, int failed, SendingStatus currentSending) {
        if (notificationManager == null) {
            return;
        }
        
        String contentText;
        if (completed >= total) {
            contentText = String.format("发送完成！成功：%d，失败：%d", success, failed);
        } else {
            String currentInfo = currentSending != null ? 
                "当前：" + currentSending.getDisplayName() : "准备发送...";
            contentText = String.format("%d/%d 已发送 | %s", completed, total, currentInfo);
        }
        
        // 创建点击通知的Intent
        Intent intent = new Intent(this, MainActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        PendingIntent pendingIntent = PendingIntent.getActivity(
                this, 0, intent, 
                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
        
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
                .setSmallIcon(android.R.drawable.ic_dialog_info)
                .setContentTitle("正在发送短信")
                .setContentText(contentText)
                .setProgress(total, completed, false)
                .setPriority(NotificationCompat.PRIORITY_LOW)
                .setOngoing(completed < total)
                .setContentIntent(pendingIntent)
                .setAutoCancel(completed >= total);
        
        // 如果发送完成，添加详细统计
        if (completed >= total) {
            builder.setStyle(new NotificationCompat.BigTextStyle()
                    .bigText(String.format("批量发送完成！\n总计：%d\n成功：%d\n失败：%d", 
                            total, success, failed)));
        }
        
        notificationManager.notify(NOTIFICATION_ID, builder.build());
    }
    
    /**
     * 取消通知
     */
    private void cancelNotification() {
        if (notificationManager != null) {
            notificationManager.cancel(NOTIFICATION_ID);
        }
    }
    
    /**
     * 重置发送状态（启用按钮，恢复文本）
     */
    private void resetSendState() {
        isSending = false;
        btnSendSMS.setEnabled(true);
        btnSendSMS.setText("发送短信");
        
        // 清空保存的消息内容
        currentSendingMessage = null;
        
        // 隐藏进度卡片
        if (cardSendingProgress != null) {
            cardSendingProgress.setVisibility(View.GONE);
        }
        
        // 清空状态列表
        sendingStatusList.clear();
        
        // 取消通知
        cancelNotification();
        
        // 不再自动关闭BottomSheet，让用户手动点击关闭按钮
        // 注意：progressBottomSheet 会在用户手动关闭时自动清理
    }

    /**
     * 根据Android版本获取PendingIntent的flags
     * Android 12 (API 31)+ 必须使用FLAG_IMMUTABLE
     * Android 12以下可以使用FLAG_UPDATE_CURRENT
     */
    private int getPendingIntentFlags() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            // Android 12+ 必须使用FLAG_IMMUTABLE
            return PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE;
        } else {
            // Android 12以下使用FLAG_UPDATE_CURRENT即可
            return PendingIntent.FLAG_UPDATE_CURRENT;
        }
    }

    private void sendSingleSMS(SmsManager smsManager, String phoneNumber, String message) {
        try {
            // 使用递增的计数器确保 PendingIntent request code 的唯一性
            int sentRequestCode = pendingIntentRequestCode++;
            int deliveredRequestCode = pendingIntentRequestCode++;
            
            // 根据Android版本选择合适的flags
            int flags = getPendingIntentFlags();
            
            Intent sentIntent = new Intent(SMS_SENT_ACTION);
            sentIntent.putExtra("phone_number", phoneNumber); // 添加电话号码以便在结果中识别
            PendingIntent sentPendingIntent = PendingIntent.getBroadcast(
                this, sentRequestCode, sentIntent, flags
            );
            
            Intent deliveredIntent = new Intent(SMS_DELIVERED_ACTION);
            deliveredIntent.putExtra("phone_number", phoneNumber);
            PendingIntent deliveredPendingIntent = PendingIntent.getBroadcast(
                this, deliveredRequestCode, deliveredIntent, flags
            );
            
            Log.d(TAG, "sendSingleSMS: 创建PendingIntent，flags=0x" + Integer.toHexString(flags) + 
                  " (Android " + Build.VERSION.SDK_INT + ")");
            
            // 使用 divideMessage 自动检测是否需要拆分
            // 对于中文短信，每条最多70个字符（UTF-16编码）
            // 对于英文短信，每条最多160个字符（7位编码）
            // divideMessage 会自动检测编码并正确拆分
            ArrayList<String> parts = smsManager.divideMessage(message);
            
            if (parts.size() > 1) {
                // 需要拆分成多条短信
                ArrayList<PendingIntent> sentIntents = new ArrayList<>();
                ArrayList<PendingIntent> deliveredIntents = new ArrayList<>();
                
                // 使用已在方法开始时定义的flags变量
                for (int i = 0; i < parts.size(); i++) {
                    Intent partSentIntent = new Intent(SMS_SENT_ACTION);
                    partSentIntent.putExtra("phone_number", phoneNumber);
                    partSentIntent.putExtra("part_index", i);
                    partSentIntent.putExtra("total_parts", parts.size());
                    sentIntents.add(PendingIntent.getBroadcast(
                        this, pendingIntentRequestCode++, partSentIntent, flags
                    ));
                    
                    Intent partDeliveredIntent = new Intent(SMS_DELIVERED_ACTION);
                    partDeliveredIntent.putExtra("phone_number", phoneNumber);
                    partDeliveredIntent.putExtra("part_index", i);
                    partDeliveredIntent.putExtra("total_parts", parts.size());
                    deliveredIntents.add(PendingIntent.getBroadcast(
                        this, pendingIntentRequestCode++, partDeliveredIntent, flags
                    ));
                }
                
                // 发送前验证参数
                if (phoneNumber == null || phoneNumber.trim().isEmpty()) {
                    Log.e(TAG, "sendSingleSMS: 电话号码为空，无法发送");
                    throw new IllegalArgumentException("电话号码不能为空");
                }
                if (parts == null || parts.isEmpty()) {
                    Log.e(TAG, "sendSingleSMS: 短信内容为空，无法发送");
                    throw new IllegalArgumentException("短信内容不能为空");
                }
                
                Log.i(TAG, "sendSingleSMS: 准备发送长短信到 " + phoneNumber + 
                      " (共 " + parts.size() + " 条分片，总长度 " + message.length() + " 字符)");
                
                smsManager.sendMultipartTextMessage(
                    phoneNumber, null, parts, sentIntents, deliveredIntents
                );
                Log.i(TAG, "sendSingleSMS: 长短信发送请求已成功提交到系统 " + phoneNumber);
                // 详细记录每条分片的内容长度（只记录前50个字符，避免日志过长）
                for (int i = 0; i < parts.size(); i++) {
                    String part = parts.get(i);
                    String preview = part.length() > 50 ? part.substring(0, 50) + "..." : part;
                    Log.d(TAG, "sendSingleSMS: 分片 " + (i + 1) + "/" + parts.size() + 
                          " (" + part.length() + " 字符): " + preview);
                }
            } else {
                // 单条短信
                // 发送前验证参数
                if (phoneNumber == null || phoneNumber.trim().isEmpty()) {
                    Log.e(TAG, "sendSingleSMS: 电话号码为空，无法发送");
                    throw new IllegalArgumentException("电话号码不能为空");
                }
                if (message == null || message.trim().isEmpty()) {
                    Log.e(TAG, "sendSingleSMS: 短信内容为空，无法发送");
                    throw new IllegalArgumentException("短信内容不能为空");
                }
                
                Log.i(TAG, "sendSingleSMS: 准备发送单条短信到 " + phoneNumber + 
                      " (长度 " + message.length() + " 字符)");
                
                smsManager.sendTextMessage(
                    phoneNumber, null, message, sentPendingIntent, deliveredPendingIntent
                );
                Log.i(TAG, "sendSingleSMS: 短信发送请求已成功提交到系统 " + phoneNumber);
            }
        } catch (SecurityException e) {
            Log.e(TAG, "sendSingleSMS: 权限不足，发送失败到 " + phoneNumber, e);
            Log.e(TAG, "sendSingleSMS: SecurityException详情 - " + e.getMessage());
            Log.e(TAG, "sendSingleSMS: 请检查：1) SEND_SMS权限是否授予 2) 是否在MIUI系统上需要额外权限");
            failCount++;
            // Handler回调已在主线程，不需要runOnUiThread
            Toast.makeText(this, "发送失败（权限问题）: " + phoneNumber, Toast.LENGTH_SHORT).show();
        } catch (IllegalArgumentException e) {
            Log.e(TAG, "sendSingleSMS: 参数错误，发送失败到 " + phoneNumber, e);
            Log.e(TAG, "sendSingleSMS: IllegalArgumentException详情 - " + e.getMessage());
            failCount++;
            // Handler回调已在主线程，不需要runOnUiThread
            String errorMsg = e.getMessage();
            if (errorMsg != null && errorMsg.contains("电话号码")) {
                Toast.makeText(this, "发送失败（电话号码为空）: " + phoneNumber, Toast.LENGTH_SHORT).show();
            } else if (errorMsg != null && errorMsg.contains("短信内容")) {
                Toast.makeText(this, "发送失败（短信内容为空）", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "发送失败（号码格式错误）: " + phoneNumber, Toast.LENGTH_SHORT).show();
            }
        } catch (Exception e) {
            Log.e(TAG, "sendSingleSMS: 发送失败到 " + phoneNumber, e);
            Log.e(TAG, "sendSingleSMS: Exception类型: " + e.getClass().getName());
            Log.e(TAG, "sendSingleSMS: Exception详情: " + e.getMessage());
            if (e.getCause() != null) {
                Log.e(TAG, "sendSingleSMS: 原因: " + e.getCause().getMessage());
            }
            failCount++;
            // Handler回调已在主线程，不需要runOnUiThread
            Toast.makeText(this, "发送失败: " + phoneNumber + " - " + (e.getMessage() != null ? e.getMessage() : "未知错误"), Toast.LENGTH_SHORT).show();
        }
    }
}